home *** CD-ROM | disk | FTP | other *** search
/ NeXTSTEP 3.3 (Developer)…68k, x86, SPARC, PA-RISC] / NeXTSTEP 3.3 Dev Intel.iso / NextDeveloper / Source / GNU / cc / cexp.c < prev    next >
C/C++ Source or Header  |  1993-10-19  |  50KB  |  1,877 lines
  1.  
  2. /*  A Bison parser, made from cexp.y  */
  3.  
  4. #define YYBISON 1  /* Identify Bison output.  */
  5.  
  6. #define    INT    258
  7. #define    CHAR    259
  8. #define    NAME    260
  9. #define    ERROR    261
  10. #define    OR    262
  11. #define    AND    263
  12. #define    EQUAL    264
  13. #define    NOTEQUAL    265
  14. #define    LEQ    266
  15. #define    GEQ    267
  16. #define    LSH    268
  17. #define    RSH    269
  18. #define    UNARY    270
  19.  
  20. #line 26 "cexp.y"
  21.  
  22. #include "config.h"
  23. #include <setjmp.h>
  24. /* #define YYDEBUG 1 */
  25.  
  26. #ifdef MULTIBYTE_CHARS
  27. #include <stdlib.h>
  28. #include <locale.h>
  29. #endif
  30.  
  31. #include <stdio.h>
  32.  
  33. typedef unsigned char U_CHAR;
  34.  
  35. /* This is used for communicating lists of keywords with cccp.c.  */
  36. struct arglist {
  37.   struct arglist *next;
  38.   U_CHAR *name;
  39.   int length;
  40.   int argno;
  41. };
  42.  
  43. /* Define a generic NULL if one hasn't already been defined.  */
  44.  
  45. #ifndef NULL
  46. #define NULL 0
  47. #endif
  48.  
  49. #ifndef GENERIC_PTR
  50. #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
  51. #define GENERIC_PTR void *
  52. #else
  53. #define GENERIC_PTR char *
  54. #endif
  55. #endif
  56.  
  57. #ifndef NULL_PTR
  58. #define NULL_PTR ((GENERIC_PTR)0)
  59. #endif
  60.  
  61. int yylex ();
  62. void yyerror ();
  63. int expression_value;
  64.  
  65. static jmp_buf parse_return_error;
  66.  
  67. /* Nonzero means count most punctuation as part of a name.  */
  68. static int keyword_parsing = 0;
  69.  
  70. /* some external tables of character types */
  71. extern unsigned char is_idstart[], is_idchar[], is_hor_space[];
  72.  
  73. extern char *xmalloc ();
  74.  
  75. /* Flag for -pedantic.  */
  76. extern int pedantic;
  77.  
  78. /* Flag for -traditional.  */
  79. extern int traditional;
  80.  
  81. #ifndef CHAR_TYPE_SIZE
  82. #define CHAR_TYPE_SIZE BITS_PER_UNIT
  83. #endif
  84.  
  85. #ifndef INT_TYPE_SIZE
  86. #define INT_TYPE_SIZE BITS_PER_WORD
  87. #endif
  88.  
  89. #ifndef LONG_TYPE_SIZE
  90. #define LONG_TYPE_SIZE BITS_PER_WORD
  91. #endif
  92.  
  93. #ifndef WCHAR_TYPE_SIZE
  94. #define WCHAR_TYPE_SIZE INT_TYPE_SIZE
  95. #endif
  96.  
  97. #ifndef MAX_CHAR_TYPE_SIZE
  98. #define MAX_CHAR_TYPE_SIZE CHAR_TYPE_SIZE
  99. #endif
  100.  
  101. #ifndef MAX_INT_TYPE_SIZE
  102. #define MAX_INT_TYPE_SIZE INT_TYPE_SIZE
  103. #endif
  104.  
  105. #ifndef MAX_LONG_TYPE_SIZE
  106. #define MAX_LONG_TYPE_SIZE LONG_TYPE_SIZE
  107. #endif
  108.  
  109. #ifndef MAX_WCHAR_TYPE_SIZE
  110. #define MAX_WCHAR_TYPE_SIZE WCHAR_TYPE_SIZE
  111. #endif
  112.  
  113. /* Yield nonzero if adding two numbers with A's and B's signs can yield a
  114.    number with SUM's sign, where A, B, and SUM are all C integers.  */
  115. #define possible_sum_sign(a, b, sum) ((((a) ^ (b)) | ~ ((a) ^ (sum))) < 0)
  116.  
  117. static void integer_overflow ();
  118. static long left_shift ();
  119. static long right_shift ();
  120.  
  121. #line 127 "cexp.y"
  122. typedef union {
  123.   struct constant {long value; int unsignedp;} integer;
  124.   struct name {U_CHAR *address; int length;} name;
  125.   struct arglist *keywords;
  126.   int voidval;
  127.   char *sval;
  128. } YYSTYPE;
  129.  
  130. #ifndef YYLTYPE
  131. typedef
  132.   struct yyltype
  133.     {
  134.       int timestamp;
  135.       int first_line;
  136.       int first_column;
  137.       int last_line;
  138.       int last_column;
  139.       char *text;
  140.    }
  141.   yyltype;
  142.  
  143. #define YYLTYPE yyltype
  144. #endif
  145.  
  146. #include <stdio.h>
  147.  
  148. #ifndef __STDC__
  149. #define const
  150. #endif
  151.  
  152.  
  153.  
  154. #define    YYFINAL        73
  155. #define    YYFLAG        -32768
  156. #define    YYNTBASE    34
  157.  
  158. #define YYTRANSLATE(x) ((unsigned)(x) <= 270 ? yytranslate[x] : 39)
  159.  
  160. static const char yytranslate[] = {     0,
  161.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  162.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  163.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  164.      2,     2,    29,     2,    31,     2,    27,    14,     2,    32,
  165.     33,    25,    23,     9,    24,     2,    26,     2,     2,     2,
  166.      2,     2,     2,     2,     2,     2,     2,     8,     2,    17,
  167.      2,    18,     7,     2,     2,     2,     2,     2,     2,     2,
  168.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  169.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  170.      2,     2,     2,    13,     2,     2,     2,     2,     2,     2,
  171.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  172.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  173.      2,     2,     2,    12,     2,    30,     2,     2,     2,     2,
  174.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  175.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  176.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  177.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  178.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  179.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  180.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  181.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  182.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  183.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  184.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  185.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  186.      2,     2,     2,     2,     2,     1,     2,     3,     4,     5,
  187.      6,    10,    11,    15,    16,    19,    20,    21,    22,    28
  188. };
  189.  
  190. static const short yyprhs[] = {     0,
  191.      0,     2,     4,     8,    11,    14,    17,    20,    23,    24,
  192.     31,    35,    39,    43,    47,    51,    55,    59,    63,    67,
  193.     71,    75,    79,    83,    87,    91,    95,    99,   103,   107,
  194.    113,   115,   117,   119,   120,   125
  195. };
  196.  
  197. static const short yyrhs[] = {    35,
  198.      0,    36,     0,    35,     9,    36,     0,    24,    36,     0,
  199.     29,    36,     0,    23,    36,     0,    30,    36,     0,    31,
  200.      5,     0,     0,    31,     5,    37,    32,    38,    33,     0,
  201.     32,    35,    33,     0,    36,    25,    36,     0,    36,    26,
  202.     36,     0,    36,    27,    36,     0,    36,    23,    36,     0,
  203.     36,    24,    36,     0,    36,    21,    36,     0,    36,    22,
  204.     36,     0,    36,    15,    36,     0,    36,    16,    36,     0,
  205.     36,    19,    36,     0,    36,    20,    36,     0,    36,    17,
  206.     36,     0,    36,    18,    36,     0,    36,    14,    36,     0,
  207.     36,    13,    36,     0,    36,    12,    36,     0,    36,    11,
  208.     36,     0,    36,    10,    36,     0,    36,     7,    36,     8,
  209.     36,     0,     3,     0,     4,     0,     5,     0,     0,    32,
  210.     38,    33,    38,     0,     5,    38,     0
  211. };
  212.  
  213. #if YYDEBUG != 0
  214. static const short yyrline[] = { 0,
  215.    159,   164,   165,   172,   177,   180,   182,   185,   189,   191,
  216.    196,   201,   213,   228,   239,   246,   253,   259,   265,   268,
  217.    271,   277,   283,   289,   295,   298,   301,   304,   307,   310,
  218.    313,   315,   317,   322,   324,   337
  219. };
  220.  
  221. static const char * const yytname[] = {   "$","error","$illegal.","INT","CHAR",
  222. "NAME","ERROR","'?'","':'","','","OR","AND","'|'","'^'","'&'","EQUAL","NOTEQUAL",
  223. "'<'","'>'","LEQ","GEQ","LSH","RSH","'+'","'-'","'*'","'/'","'%'","UNARY","'!'",
  224. "'~'","'#'","'('","')'","start","exp1","exp","@1","keywords",""
  225. };
  226. #endif
  227.  
  228. static const short yyr1[] = {     0,
  229.     34,    35,    35,    36,    36,    36,    36,    36,    37,    36,
  230.     36,    36,    36,    36,    36,    36,    36,    36,    36,    36,
  231.     36,    36,    36,    36,    36,    36,    36,    36,    36,    36,
  232.     36,    36,    36,    38,    38,    38
  233. };
  234.  
  235. static const short yyr2[] = {     0,
  236.      1,     1,     3,     2,     2,     2,     2,     2,     0,     6,
  237.      3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
  238.      3,     3,     3,     3,     3,     3,     3,     3,     3,     5,
  239.      1,     1,     1,     0,     4,     2
  240. };
  241.  
  242. static const short yydefact[] = {     0,
  243.     31,    32,    33,     0,     0,     0,     0,     0,     0,     1,
  244.      2,     6,     4,     5,     7,     8,     0,     0,     0,     0,
  245.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  246.      0,     0,     0,     0,     0,     0,     0,     0,    11,     3,
  247.      0,    29,    28,    27,    26,    25,    19,    20,    23,    24,
  248.     21,    22,    17,    18,    15,    16,    12,    13,    14,    34,
  249.      0,    34,    34,     0,    30,    36,     0,    10,    34,    35,
  250.      0,     0,     0
  251. };
  252.  
  253. static const short yydefgoto[] = {    71,
  254.     10,    11,    38,    64
  255. };
  256.  
  257. static const short yypact[] = {    31,
  258. -32768,-32768,-32768,    31,    31,    31,    31,     4,    31,     3,
  259.     80,-32768,-32768,-32768,-32768,     6,    32,    31,    31,    31,
  260.     31,    31,    31,    31,    31,    31,    31,    31,    31,    31,
  261.     31,    31,    31,    31,    31,    31,    31,     7,-32768,    80,
  262.     59,    97,   113,   128,   142,   155,    25,    25,   162,   162,
  263.    162,   162,   167,   167,   -19,   -19,-32768,-32768,-32768,     5,
  264.     31,     5,     5,   -20,    80,-32768,    20,-32768,     5,-32768,
  265.     40,    56,-32768
  266. };
  267.  
  268. static const short yypgoto[] = {-32768,
  269.     49,    -4,-32768,   -58
  270. };
  271.  
  272.  
  273. #define    YYLAST        194
  274.  
  275.  
  276. static const short yytable[] = {    12,
  277.     13,    14,    15,    66,    67,    35,    36,    37,    16,    62,
  278.     70,    18,    68,    40,    41,    42,    43,    44,    45,    46,
  279.     47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
  280.     57,    58,    59,     1,     2,     3,    63,    -9,    60,    72,
  281.     18,    27,    28,    29,    30,    31,    32,    33,    34,    35,
  282.     36,    37,    69,     4,     5,    73,    65,    17,     0,     6,
  283.      7,     8,     9,     0,    39,    19,    61,     0,    20,    21,
  284.     22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
  285.     32,    33,    34,    35,    36,    37,    19,     0,     0,    20,
  286.     21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
  287.     31,    32,    33,    34,    35,    36,    37,    21,    22,    23,
  288.     24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
  289.     34,    35,    36,    37,    22,    23,    24,    25,    26,    27,
  290.     28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
  291.     23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
  292.     33,    34,    35,    36,    37,    24,    25,    26,    27,    28,
  293.     29,    30,    31,    32,    33,    34,    35,    36,    37,    25,
  294.     26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
  295.     36,    37,    31,    32,    33,    34,    35,    36,    37,    33,
  296.     34,    35,    36,    37
  297. };
  298.  
  299. static const short yycheck[] = {     4,
  300.      5,     6,     7,    62,    63,    25,    26,    27,     5,     5,
  301.     69,     9,    33,    18,    19,    20,    21,    22,    23,    24,
  302.     25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
  303.     35,    36,    37,     3,     4,     5,    32,    32,    32,     0,
  304.      9,    17,    18,    19,    20,    21,    22,    23,    24,    25,
  305.     26,    27,    33,    23,    24,     0,    61,     9,    -1,    29,
  306.     30,    31,    32,    -1,    33,     7,     8,    -1,    10,    11,
  307.     12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
  308.     22,    23,    24,    25,    26,    27,     7,    -1,    -1,    10,
  309.     11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
  310.     21,    22,    23,    24,    25,    26,    27,    11,    12,    13,
  311.     14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
  312.     24,    25,    26,    27,    12,    13,    14,    15,    16,    17,
  313.     18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
  314.     13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
  315.     23,    24,    25,    26,    27,    14,    15,    16,    17,    18,
  316.     19,    20,    21,    22,    23,    24,    25,    26,    27,    15,
  317.     16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
  318.     26,    27,    21,    22,    23,    24,    25,    26,    27,    23,
  319.     24,    25,    26,    27
  320. };
  321. /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
  322. #line 3 "bison.simple"
  323.  
  324. /* Skeleton output parser for bison,
  325.    Copyright (C) 1984, 1989, 1990 Bob Corbett and Richard Stallman
  326.  
  327.    This program is free software; you can redistribute it and/or modify
  328.    it under the terms of the GNU General Public License as published by
  329.    the Free Software Foundation; either version 1, or (at your option)
  330.    any later version.
  331.  
  332.    This program is distributed in the hope that it will be useful,
  333.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  334.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  335.    GNU General Public License for more details.
  336.  
  337.    You should have received a copy of the GNU General Public License
  338.    along with this program; if not, write to the Free Software
  339.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  340.  
  341.  
  342. #ifndef alloca
  343. #ifdef __GNUC__
  344. #define alloca __builtin_alloca
  345. #else /* not GNU C.  */
  346. #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__)
  347. #include <alloca.h>
  348. #else /* not sparc */
  349. #if defined (MSDOS) && !defined (__TURBOC__)
  350. #include <malloc.h>
  351. #else /* not MSDOS, or __TURBOC__ */
  352. #if defined(_AIX)
  353. #include <malloc.h>
  354.  #pragma alloca
  355. #endif /* not _AIX */
  356. #endif /* not MSDOS, or __TURBOC__ */
  357. #endif /* not sparc.  */
  358. #endif /* not GNU C.  */
  359. #endif /* alloca not defined.  */
  360.  
  361. /* This is the parser code that is written into each bison parser
  362.   when the %semantic_parser declaration is not specified in the grammar.
  363.   It was written by Richard Stallman by simplifying the hairy parser
  364.   used when %semantic_parser is specified.  */
  365.  
  366. /* Note: there must be only one dollar sign in this file.
  367.    It is replaced by the list of actions, each action
  368.    as one case of the switch.  */
  369.  
  370. #define yyerrok        (yyerrstatus = 0)
  371. #define yyclearin    (yychar = YYEMPTY)
  372. #define YYEMPTY        -2
  373. #define YYEOF        0
  374. #define YYACCEPT    return(0)
  375. #define YYABORT     return(1)
  376. #define YYERROR        goto yyerrlab1
  377. /* Like YYERROR except do call yyerror.
  378.    This remains here temporarily to ease the
  379.    transition to the new meaning of YYERROR, for GCC.
  380.    Once GCC version 2 has supplanted version 1, this can go.  */
  381. #define YYFAIL        goto yyerrlab
  382. #define YYRECOVERING()  (!!yyerrstatus)
  383. #define YYBACKUP(token, value) \
  384. do                                \
  385.   if (yychar == YYEMPTY && yylen == 1)                \
  386.     { yychar = (token), yylval = (value);            \
  387.       yychar1 = YYTRANSLATE (yychar);                \
  388.       YYPOPSTACK;                        \
  389.       goto yybackup;                        \
  390.     }                                \
  391.   else                                \
  392.     { yyerror ("syntax error: cannot back up"); YYERROR; }    \
  393. while (0)
  394.  
  395. #define YYTERROR    1
  396. #define YYERRCODE    256
  397.  
  398. #ifndef YYPURE
  399. #define YYLEX        yylex()
  400. #endif
  401.  
  402. #ifdef YYPURE
  403. #ifdef YYLSP_NEEDED
  404. #define YYLEX        yylex(&yylval, &yylloc)
  405. #else
  406. #define YYLEX        yylex(&yylval)
  407. #endif
  408. #endif
  409.  
  410. /* If nonreentrant, generate the variables here */
  411.  
  412. #ifndef YYPURE
  413.  
  414. int    yychar;            /*  the lookahead symbol        */
  415. YYSTYPE    yylval;            /*  the semantic value of the        */
  416.                 /*  lookahead symbol            */
  417.  
  418. #ifdef YYLSP_NEEDED
  419. YYLTYPE yylloc;            /*  location data for the lookahead    */
  420.                 /*  symbol                */
  421. #endif
  422.  
  423. int yynerrs;            /*  number of parse errors so far       */
  424. #endif  /* not YYPURE */
  425.  
  426. #if YYDEBUG != 0
  427. int yydebug;            /*  nonzero means print parse trace    */
  428. /* Since this is uninitialized, it does not stop multiple parsers
  429.    from coexisting.  */
  430. #endif
  431.  
  432. /*  YYINITDEPTH indicates the initial size of the parser's stacks    */
  433.  
  434. #ifndef    YYINITDEPTH
  435. #define YYINITDEPTH 200
  436. #endif
  437.  
  438. /*  YYMAXDEPTH is the maximum size the stacks can grow to
  439.     (effective only if the built-in stack extension method is used).  */
  440.  
  441. #if YYMAXDEPTH == 0
  442. #undef YYMAXDEPTH
  443. #endif
  444.  
  445. #ifndef YYMAXDEPTH
  446. #define YYMAXDEPTH 10000
  447. #endif
  448.  
  449. #if __GNUC__ > 1        /* GNU C and GNU C++ define this.  */
  450. #define __yy_bcopy(FROM,TO,COUNT)    __builtin_memcpy(TO,FROM,COUNT)
  451. #else                /* not GNU C or C++ */
  452. #ifndef __cplusplus
  453.  
  454. /* This is the most reliable way to avoid incompatibilities
  455.    in available built-in functions on various systems.  */
  456. static void
  457. __yy_bcopy (from, to, count)
  458.      char *from;
  459.      char *to;
  460.      int count;
  461. {
  462.   register char *f = from;
  463.   register char *t = to;
  464.   register int i = count;
  465.  
  466.   while (i-- > 0)
  467.     *t++ = *f++;
  468. }
  469.  
  470. #else /* __cplusplus */
  471.  
  472. /* This is the most reliable way to avoid incompatibilities
  473.    in available built-in functions on various systems.  */
  474. static void
  475. __yy_bcopy (char *from, char *to, int count)
  476. {
  477.   register char *f = from;
  478.   register char *t = to;
  479.   register int i = count;
  480.  
  481.   while (i-- > 0)
  482.     *t++ = *f++;
  483. }
  484.  
  485. #endif
  486. #endif
  487.  
  488. #line 169 "bison.simple"
  489. int
  490. yyparse()
  491. {
  492.   register int yystate;
  493.   register int yyn;
  494.   register short *yyssp;
  495.   register YYSTYPE *yyvsp;
  496.   int yyerrstatus;    /*  number of tokens to shift before error messages enabled */
  497.   int yychar1;        /*  lookahead token as an internal (translated) token number */
  498.  
  499.   short    yyssa[YYINITDEPTH];    /*  the state stack            */
  500.   YYSTYPE yyvsa[YYINITDEPTH];    /*  the semantic value stack        */
  501.  
  502.   short *yyss = yyssa;        /*  refer to the stacks thru separate pointers */
  503.   YYSTYPE *yyvs = yyvsa;    /*  to allow yyoverflow to reallocate them elsewhere */
  504.  
  505. #ifdef YYLSP_NEEDED
  506.   YYLTYPE yylsa[YYINITDEPTH];    /*  the location stack            */
  507.   YYLTYPE *yyls = yylsa;
  508.   YYLTYPE *yylsp;
  509.  
  510. #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
  511. #else
  512. #define YYPOPSTACK   (yyvsp--, yyssp--)
  513. #endif
  514.  
  515.   int yystacksize = YYINITDEPTH;
  516.  
  517. #ifdef YYPURE
  518.   int yychar;
  519.   YYSTYPE yylval;
  520.   int yynerrs;
  521. #ifdef YYLSP_NEEDED
  522.   YYLTYPE yylloc;
  523. #endif
  524. #endif
  525.  
  526.   YYSTYPE yyval;        /*  the variable used to return        */
  527.                 /*  semantic values from the action    */
  528.                 /*  routines                */
  529.  
  530.   int yylen;
  531.  
  532. #if YYDEBUG != 0
  533.   if (yydebug)
  534.     fprintf(stderr, "Starting parse\n");
  535. #endif
  536.  
  537.   yystate = 0;
  538.   yyerrstatus = 0;
  539.   yynerrs = 0;
  540.   yychar = YYEMPTY;        /* Cause a token to be read.  */
  541.  
  542.   /* Initialize stack pointers.
  543.      Waste one element of value and location stack
  544.      so that they stay on the same level as the state stack.  */
  545.  
  546.   yyssp = yyss - 1;
  547.   yyvsp = yyvs;
  548. #ifdef YYLSP_NEEDED
  549.   yylsp = yyls;
  550. #endif
  551.  
  552. /* Push a new state, which is found in  yystate  .  */
  553. /* In all cases, when you get here, the value and location stacks
  554.    have just been pushed. so pushing a state here evens the stacks.  */
  555. yynewstate:
  556.  
  557.   *++yyssp = yystate;
  558.  
  559.   if (yyssp >= yyss + yystacksize - 1)
  560.     {
  561.       /* Give user a chance to reallocate the stack */
  562.       /* Use copies of these so that the &'s don't force the real ones into memory. */
  563.       YYSTYPE *yyvs1 = yyvs;
  564.       short *yyss1 = yyss;
  565. #ifdef YYLSP_NEEDED
  566.       YYLTYPE *yyls1 = yyls;
  567. #endif
  568.  
  569.       /* Get the current used size of the three stacks, in elements.  */
  570.       int size = yyssp - yyss + 1;
  571.  
  572. #ifdef yyoverflow
  573.       /* Each stack pointer address is followed by the size of
  574.      the data in use in that stack, in bytes.  */
  575.       yyoverflow("parser stack overflow",
  576.          &yyss1, size * sizeof (*yyssp),
  577.          &yyvs1, size * sizeof (*yyvsp),
  578. #ifdef YYLSP_NEEDED
  579.          &yyls1, size * sizeof (*yylsp),
  580. #endif
  581.          &yystacksize);
  582.  
  583.       yyss = yyss1; yyvs = yyvs1;
  584. #ifdef YYLSP_NEEDED
  585.       yyls = yyls1;
  586. #endif
  587. #else /* no yyoverflow */
  588.       /* Extend the stack our own way.  */
  589.       if (yystacksize >= YYMAXDEPTH)
  590.     {
  591.       yyerror("parser stack overflow");
  592.       return 2;
  593.     }
  594.       yystacksize *= 2;
  595.       if (yystacksize > YYMAXDEPTH)
  596.     yystacksize = YYMAXDEPTH;
  597.       yyss = (short *) alloca (yystacksize * sizeof (*yyssp));
  598.       __yy_bcopy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp));
  599.       yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));
  600.       __yy_bcopy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp));
  601. #ifdef YYLSP_NEEDED
  602.       yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));
  603.       __yy_bcopy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp));
  604. #endif
  605. #endif /* no yyoverflow */
  606.  
  607.       yyssp = yyss + size - 1;
  608.       yyvsp = yyvs + size - 1;
  609. #ifdef YYLSP_NEEDED
  610.       yylsp = yyls + size - 1;
  611. #endif
  612.  
  613. #if YYDEBUG != 0
  614.       if (yydebug)
  615.     fprintf(stderr, "Stack size increased to %d\n", yystacksize);
  616. #endif
  617.  
  618.       if (yyssp >= yyss + yystacksize - 1)
  619.     YYABORT;
  620.     }
  621.  
  622. #if YYDEBUG != 0
  623.   if (yydebug)
  624.     fprintf(stderr, "Entering state %d\n", yystate);
  625. #endif
  626.  
  627.  yybackup:
  628.  
  629. /* Do appropriate processing given the current state.  */
  630. /* Read a lookahead token if we need one and don't already have one.  */
  631. /* yyresume: */
  632.  
  633.   /* First try to decide what to do without reference to lookahead token.  */
  634.  
  635.   yyn = yypact[yystate];
  636.   if (yyn == YYFLAG)
  637.     goto yydefault;
  638.  
  639.   /* Not known => get a lookahead token if don't already have one.  */
  640.  
  641.   /* yychar is either YYEMPTY or YYEOF
  642.      or a valid token in external form.  */
  643.  
  644.   if (yychar == YYEMPTY)
  645.     {
  646. #if YYDEBUG != 0
  647.       if (yydebug)
  648.     fprintf(stderr, "Reading a token: ");
  649. #endif
  650.       yychar = YYLEX;
  651.     }
  652.  
  653.   /* Convert token to internal form (in yychar1) for indexing tables with */
  654.  
  655.   if (yychar <= 0)        /* This means end of input. */
  656.     {
  657.       yychar1 = 0;
  658.       yychar = YYEOF;        /* Don't call YYLEX any more */
  659.  
  660. #if YYDEBUG != 0
  661.       if (yydebug)
  662.     fprintf(stderr, "Now at end of input.\n");
  663. #endif
  664.     }
  665.   else
  666.     {
  667.       yychar1 = YYTRANSLATE(yychar);
  668.  
  669. #if YYDEBUG != 0
  670.       if (yydebug)
  671.     {
  672.       fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
  673.       /* Give the individual parser a way to print the precise meaning
  674.          of a token, for further debugging info.  */
  675. #ifdef YYPRINT
  676.       YYPRINT (stderr, yychar, yylval);
  677. #endif
  678.       fprintf (stderr, ")\n");
  679.     }
  680. #endif
  681.     }
  682.  
  683.   yyn += yychar1;
  684.   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
  685.     goto yydefault;
  686.  
  687.   yyn = yytable[yyn];
  688.  
  689.   /* yyn is what to do for this token type in this state.
  690.      Negative => reduce, -yyn is rule number.
  691.      Positive => shift, yyn is new state.
  692.        New state is final state => don't bother to shift,
  693.        just return success.
  694.      0, or most negative number => error.  */
  695.  
  696.   if (yyn < 0)
  697.     {
  698.       if (yyn == YYFLAG)
  699.     goto yyerrlab;
  700.       yyn = -yyn;
  701.       goto yyreduce;
  702.     }
  703.   else if (yyn == 0)
  704.     goto yyerrlab;
  705.  
  706.   if (yyn == YYFINAL)
  707.     YYACCEPT;
  708.  
  709.   /* Shift the lookahead token.  */
  710.  
  711. #if YYDEBUG != 0
  712.   if (yydebug)
  713.     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
  714. #endif
  715.  
  716.   /* Discard the token being shifted unless it is eof.  */
  717.   if (yychar != YYEOF)
  718.     yychar = YYEMPTY;
  719.  
  720.   *++yyvsp = yylval;
  721. #ifdef YYLSP_NEEDED
  722.   *++yylsp = yylloc;
  723. #endif
  724.  
  725.   /* count tokens shifted since error; after three, turn off error status.  */
  726.   if (yyerrstatus) yyerrstatus--;
  727.  
  728.   yystate = yyn;
  729.   goto yynewstate;
  730.  
  731. /* Do the default action for the current state.  */
  732. yydefault:
  733.  
  734.   yyn = yydefact[yystate];
  735.   if (yyn == 0)
  736.     goto yyerrlab;
  737.  
  738. /* Do a reduction.  yyn is the number of a rule to reduce with.  */
  739. yyreduce:
  740.   yylen = yyr2[yyn];
  741.   yyval = yyvsp[1-yylen]; /* implement default value of the action */
  742.  
  743. #if YYDEBUG != 0
  744.   if (yydebug)
  745.     {
  746.       int i;
  747.  
  748.       fprintf (stderr, "Reducing via rule %d (line %d), ",
  749.            yyn, yyrline[yyn]);
  750.  
  751.       /* Print the symboles being reduced, and their result.  */
  752.       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
  753.     fprintf (stderr, "%s ", yytname[yyrhs[i]]);
  754.       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
  755.     }
  756. #endif
  757.  
  758.  
  759.   switch (yyn) {
  760.  
  761. case 1:
  762. #line 160 "cexp.y"
  763. { expression_value = yyvsp[0].integer.value; ;
  764.     break;}
  765. case 3:
  766. #line 166 "cexp.y"
  767. { if (pedantic)
  768.                 pedwarn ("comma operator in operand of `#if'");
  769.               yyval.integer = yyvsp[0].integer; ;
  770.     break;}
  771. case 4:
  772. #line 173 "cexp.y"
  773. { yyval.integer.value = - yyvsp[0].integer.value;
  774.               if ((yyval.integer.value & yyvsp[0].integer.value) < 0 && ! yyvsp[0].integer.unsignedp)
  775.                 integer_overflow ();
  776.               yyval.integer.unsignedp = yyvsp[0].integer.unsignedp; ;
  777.     break;}
  778. case 5:
  779. #line 178 "cexp.y"
  780. { yyval.integer.value = ! yyvsp[0].integer.value;
  781.               yyval.integer.unsignedp = 0; ;
  782.     break;}
  783. case 6:
  784. #line 181 "cexp.y"
  785. { yyval.integer = yyvsp[0].integer; ;
  786.     break;}
  787. case 7:
  788. #line 183 "cexp.y"
  789. { yyval.integer.value = ~ yyvsp[0].integer.value;
  790.               yyval.integer.unsignedp = yyvsp[0].integer.unsignedp; ;
  791.     break;}
  792. case 8:
  793. #line 186 "cexp.y"
  794. { yyval.integer.value = check_assertion (yyvsp[0].name.address, yyvsp[0].name.length,
  795.                               0, NULL_PTR);
  796.               yyval.integer.unsignedp = 0; ;
  797.     break;}
  798. case 9:
  799. #line 190 "cexp.y"
  800. { keyword_parsing = 1; ;
  801.     break;}
  802. case 10:
  803. #line 192 "cexp.y"
  804. { yyval.integer.value = check_assertion (yyvsp[-4].name.address, yyvsp[-4].name.length,
  805.                               1, yyvsp[-1].keywords);
  806.               keyword_parsing = 0;
  807.               yyval.integer.unsignedp = 0; ;
  808.     break;}
  809. case 11:
  810. #line 197 "cexp.y"
  811. { yyval.integer = yyvsp[-1].integer; ;
  812.     break;}
  813. case 12:
  814. #line 202 "cexp.y"
  815. { yyval.integer.unsignedp = yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp;
  816.               if (yyval.integer.unsignedp)
  817.                 yyval.integer.value = (unsigned long) yyvsp[-2].integer.value * yyvsp[0].integer.value;
  818.               else
  819.                 {
  820.                   yyval.integer.value = yyvsp[-2].integer.value * yyvsp[0].integer.value;
  821.                   if (yyvsp[-2].integer.value
  822.                   && (yyval.integer.value / yyvsp[-2].integer.value != yyvsp[0].integer.value
  823.                       || (yyval.integer.value & yyvsp[-2].integer.value & yyvsp[0].integer.value) < 0))
  824.                 integer_overflow ();
  825.                 } ;
  826.     break;}
  827. case 13:
  828. #line 214 "cexp.y"
  829. { if (yyvsp[0].integer.value == 0)
  830.                 {
  831.                   error ("division by zero in #if");
  832.                   yyvsp[0].integer.value = 1;
  833.                 }
  834.               yyval.integer.unsignedp = yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp;
  835.               if (yyval.integer.unsignedp)
  836.                 yyval.integer.value = (unsigned long) yyvsp[-2].integer.value / yyvsp[0].integer.value;
  837.               else
  838.                 {
  839.                   yyval.integer.value = yyvsp[-2].integer.value / yyvsp[0].integer.value;
  840.                   if ((yyval.integer.value & yyvsp[-2].integer.value & yyvsp[0].integer.value) < 0)
  841.                 integer_overflow ();
  842.                 } ;
  843.     break;}
  844. case 14:
  845. #line 229 "cexp.y"
  846. { if (yyvsp[0].integer.value == 0)
  847.                 {
  848.                   error ("division by zero in #if");
  849.                   yyvsp[0].integer.value = 1;
  850.                 }
  851.               yyval.integer.unsignedp = yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp;
  852.               if (yyval.integer.unsignedp)
  853.                 yyval.integer.value = (unsigned long) yyvsp[-2].integer.value % yyvsp[0].integer.value;
  854.               else
  855.                 yyval.integer.value = yyvsp[-2].integer.value % yyvsp[0].integer.value; ;
  856.     break;}
  857. case 15:
  858. #line 240 "cexp.y"
  859. { yyval.integer.value = yyvsp[-2].integer.value + yyvsp[0].integer.value;
  860.               yyval.integer.unsignedp = yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp;
  861.               if (! yyval.integer.unsignedp
  862.                   && ! possible_sum_sign (yyvsp[-2].integer.value, yyvsp[0].integer.value,
  863.                               yyval.integer.value))
  864.                 integer_overflow (); ;
  865.     break;}
  866. case 16:
  867. #line 247 "cexp.y"
  868. { yyval.integer.value = yyvsp[-2].integer.value - yyvsp[0].integer.value;
  869.               yyval.integer.unsignedp = yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp;
  870.               if (! yyval.integer.unsignedp
  871.                   && ! possible_sum_sign (yyval.integer.value, yyvsp[0].integer.value,
  872.                               yyvsp[-2].integer.value))
  873.                 integer_overflow (); ;
  874.     break;}
  875. case 17:
  876. #line 254 "cexp.y"
  877. { yyval.integer.unsignedp = yyvsp[-2].integer.unsignedp;
  878.               if (yyvsp[0].integer.value < 0 && ! yyvsp[0].integer.unsignedp)
  879.                 yyval.integer.value = right_shift (&yyvsp[-2].integer, -yyvsp[0].integer.value);
  880.               else
  881.                 yyval.integer.value = left_shift (&yyvsp[-2].integer, yyvsp[0].integer.value); ;
  882.     break;}
  883. case 18:
  884. #line 260 "cexp.y"
  885. { yyval.integer.unsignedp = yyvsp[-2].integer.unsignedp;
  886.               if (yyvsp[0].integer.value < 0 && ! yyvsp[0].integer.unsignedp)
  887.                 yyval.integer.value = left_shift (&yyvsp[-2].integer, -yyvsp[0].integer.value);
  888.               else
  889.                 yyval.integer.value = right_shift (&yyvsp[-2].integer, yyvsp[0].integer.value); ;
  890.     break;}
  891. case 19:
  892. #line 266 "cexp.y"
  893. { yyval.integer.value = (yyvsp[-2].integer.value == yyvsp[0].integer.value);
  894.               yyval.integer.unsignedp = 0; ;
  895.     break;}
  896. case 20:
  897. #line 269 "cexp.y"
  898. { yyval.integer.value = (yyvsp[-2].integer.value != yyvsp[0].integer.value);
  899.               yyval.integer.unsignedp = 0; ;
  900.     break;}
  901. case 21:
  902. #line 272 "cexp.y"
  903. { yyval.integer.unsignedp = 0;
  904.               if (yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp)
  905.                 yyval.integer.value = (unsigned long) yyvsp[-2].integer.value <= yyvsp[0].integer.value;
  906.               else
  907.                 yyval.integer.value = yyvsp[-2].integer.value <= yyvsp[0].integer.value; ;
  908.     break;}
  909. case 22:
  910. #line 278 "cexp.y"
  911. { yyval.integer.unsignedp = 0;
  912.               if (yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp)
  913.                 yyval.integer.value = (unsigned long) yyvsp[-2].integer.value >= yyvsp[0].integer.value;
  914.               else
  915.                 yyval.integer.value = yyvsp[-2].integer.value >= yyvsp[0].integer.value; ;
  916.     break;}
  917. case 23:
  918. #line 284 "cexp.y"
  919. { yyval.integer.unsignedp = 0;
  920.               if (yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp)
  921.                 yyval.integer.value = (unsigned long) yyvsp[-2].integer.value < yyvsp[0].integer.value;
  922.               else
  923.                 yyval.integer.value = yyvsp[-2].integer.value < yyvsp[0].integer.value; ;
  924.     break;}
  925. case 24:
  926. #line 290 "cexp.y"
  927. { yyval.integer.unsignedp = 0;
  928.               if (yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp)
  929.                 yyval.integer.value = (unsigned long) yyvsp[-2].integer.value > yyvsp[0].integer.value;
  930.               else
  931.                 yyval.integer.value = yyvsp[-2].integer.value > yyvsp[0].integer.value; ;
  932.     break;}
  933. case 25:
  934. #line 296 "cexp.y"
  935. { yyval.integer.value = yyvsp[-2].integer.value & yyvsp[0].integer.value;
  936.               yyval.integer.unsignedp = yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp; ;
  937.     break;}
  938. case 26:
  939. #line 299 "cexp.y"
  940. { yyval.integer.value = yyvsp[-2].integer.value ^ yyvsp[0].integer.value;
  941.               yyval.integer.unsignedp = yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp; ;
  942.     break;}
  943. case 27:
  944. #line 302 "cexp.y"
  945. { yyval.integer.value = yyvsp[-2].integer.value | yyvsp[0].integer.value;
  946.               yyval.integer.unsignedp = yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp; ;
  947.     break;}
  948. case 28:
  949. #line 305 "cexp.y"
  950. { yyval.integer.value = (yyvsp[-2].integer.value && yyvsp[0].integer.value);
  951.               yyval.integer.unsignedp = 0; ;
  952.     break;}
  953. case 29:
  954. #line 308 "cexp.y"
  955. { yyval.integer.value = (yyvsp[-2].integer.value || yyvsp[0].integer.value);
  956.               yyval.integer.unsignedp = 0; ;
  957.     break;}
  958. case 30:
  959. #line 311 "cexp.y"
  960. { yyval.integer.value = yyvsp[-4].integer.value ? yyvsp[-2].integer.value : yyvsp[0].integer.value;
  961.               yyval.integer.unsignedp = yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp; ;
  962.     break;}
  963. case 31:
  964. #line 314 "cexp.y"
  965. { yyval.integer = yylval.integer; ;
  966.     break;}
  967. case 32:
  968. #line 316 "cexp.y"
  969. { yyval.integer = yylval.integer; ;
  970.     break;}
  971. case 33:
  972. #line 318 "cexp.y"
  973. { yyval.integer.value = 0;
  974.               yyval.integer.unsignedp = 0; ;
  975.     break;}
  976. case 34:
  977. #line 323 "cexp.y"
  978. { yyval.keywords = 0; ;
  979.     break;}
  980. case 35:
  981. #line 325 "cexp.y"
  982. { struct arglist *temp;
  983.               yyval.keywords = (struct arglist *) xmalloc (sizeof (struct arglist));
  984.               yyval.keywords->next = yyvsp[-2].keywords;
  985.               yyval.keywords->name = (U_CHAR *) "(";
  986.               yyval.keywords->length = 1;
  987.               temp = yyval.keywords;
  988.               while (temp != 0 && temp->next != 0)
  989.                 temp = temp->next;
  990.               temp->next = (struct arglist *) xmalloc (sizeof (struct arglist));
  991.               temp->next->next = yyvsp[0].keywords;
  992.               temp->next->name = (U_CHAR *) ")";
  993.               temp->next->length = 1; ;
  994.     break;}
  995. case 36:
  996. #line 338 "cexp.y"
  997. { yyval.keywords = (struct arglist *) xmalloc (sizeof (struct arglist));
  998.               yyval.keywords->name = yyvsp[-1].name.address;
  999.               yyval.keywords->length = yyvsp[-1].name.length;
  1000.               yyval.keywords->next = yyvsp[0].keywords; ;
  1001.     break;}
  1002. }
  1003.    /* the action file gets copied in in place of this dollarsign */
  1004. #line 440 "bison.simple"
  1005.  
  1006.   yyvsp -= yylen;
  1007.   yyssp -= yylen;
  1008. #ifdef YYLSP_NEEDED
  1009.   yylsp -= yylen;
  1010. #endif
  1011.  
  1012. #if YYDEBUG != 0
  1013.   if (yydebug)
  1014.     {
  1015.       short *ssp1 = yyss - 1;
  1016.       fprintf (stderr, "state stack now");
  1017.       while (ssp1 != yyssp)
  1018.     fprintf (stderr, " %d", *++ssp1);
  1019.       fprintf (stderr, "\n");
  1020.     }
  1021. #endif
  1022.  
  1023.   *++yyvsp = yyval;
  1024.  
  1025. #ifdef YYLSP_NEEDED
  1026.   yylsp++;
  1027.   if (yylen == 0)
  1028.     {
  1029.       yylsp->first_line = yylloc.first_line;
  1030.       yylsp->first_column = yylloc.first_column;
  1031.       yylsp->last_line = (yylsp-1)->last_line;
  1032.       yylsp->last_column = (yylsp-1)->last_column;
  1033.       yylsp->text = 0;
  1034.     }
  1035.   else
  1036.     {
  1037.       yylsp->last_line = (yylsp+yylen-1)->last_line;
  1038.       yylsp->last_column = (yylsp+yylen-1)->last_column;
  1039.     }
  1040. #endif
  1041.  
  1042.   /* Now "shift" the result of the reduction.
  1043.      Determine what state that goes to,
  1044.      based on the state we popped back to
  1045.      and the rule number reduced by.  */
  1046.  
  1047.   yyn = yyr1[yyn];
  1048.  
  1049.   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
  1050.   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
  1051.     yystate = yytable[yystate];
  1052.   else
  1053.     yystate = yydefgoto[yyn - YYNTBASE];
  1054.  
  1055.   goto yynewstate;
  1056.  
  1057. yyerrlab:   /* here on detecting error */
  1058.  
  1059.   if (! yyerrstatus)
  1060.     /* If not already recovering from an error, report this error.  */
  1061.     {
  1062.       ++yynerrs;
  1063.  
  1064. #ifdef YYERROR_VERBOSE
  1065.       yyn = yypact[yystate];
  1066.  
  1067.       if (yyn > YYFLAG && yyn < YYLAST)
  1068.     {
  1069.       int size = 0;
  1070.       char *msg;
  1071.       int x, count;
  1072.  
  1073.       count = 0;
  1074.       for (x = 0; x < (sizeof(yytname) / sizeof(char *)); x++)
  1075.         if (yycheck[x + yyn] == x)
  1076.           size += strlen(yytname[x]) + 15, count++;
  1077.       msg = (char *) malloc(size + 15);
  1078.       if (msg != 0)
  1079.         {
  1080.           strcpy(msg, "parse error");
  1081.  
  1082.           if (count < 5)
  1083.         {
  1084.           count = 0;
  1085.           for (x = 0; x < (sizeof(yytname) / sizeof(char *)); x++)
  1086.             if (yycheck[x + yyn] == x)
  1087.               {
  1088.             strcat(msg, count == 0 ? ", expecting `" : " or `");
  1089.             strcat(msg, yytname[x]);
  1090.             strcat(msg, "'");
  1091.             count++;
  1092.               }
  1093.         }
  1094.           yyerror(msg);
  1095.           free(msg);
  1096.         }
  1097.       else
  1098.         yyerror ("parse error; also virtual memory exceeded");
  1099.     }
  1100.       else
  1101. #endif /* YYERROR_VERBOSE */
  1102.     yyerror("parse error");
  1103.     }
  1104.  
  1105. yyerrlab1:   /* here on error raised explicitly by an action */
  1106.  
  1107.   if (yyerrstatus == 3)
  1108.     {
  1109.       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
  1110.  
  1111.       /* return failure if at end of input */
  1112.       if (yychar == YYEOF)
  1113.     YYABORT;
  1114.  
  1115. #if YYDEBUG != 0
  1116.       if (yydebug)
  1117.     fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
  1118. #endif
  1119.  
  1120.       yychar = YYEMPTY;
  1121.     }
  1122.  
  1123.   /* Else will try to reuse lookahead token
  1124.      after shifting the error token.  */
  1125.  
  1126.   yyerrstatus = 3;        /* Each real token shifted decrements this */
  1127.  
  1128.   goto yyerrhandle;
  1129.  
  1130. yyerrdefault:  /* current state does not do anything special for the error token. */
  1131.  
  1132. #if 0
  1133.   /* This is wrong; only states that explicitly want error tokens
  1134.      should shift them.  */
  1135.   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
  1136.   if (yyn) goto yydefault;
  1137. #endif
  1138.  
  1139. yyerrpop:   /* pop the current state because it cannot handle the error token */
  1140.  
  1141.   if (yyssp == yyss) YYABORT;
  1142.   yyvsp--;
  1143.   yystate = *--yyssp;
  1144. #ifdef YYLSP_NEEDED
  1145.   yylsp--;
  1146. #endif
  1147.  
  1148. #if YYDEBUG != 0
  1149.   if (yydebug)
  1150.     {
  1151.       short *ssp1 = yyss - 1;
  1152.       fprintf (stderr, "Error: state stack now");
  1153.       while (ssp1 != yyssp)
  1154.     fprintf (stderr, " %d", *++ssp1);
  1155.       fprintf (stderr, "\n");
  1156.     }
  1157. #endif
  1158.  
  1159. yyerrhandle:
  1160.  
  1161.   yyn = yypact[yystate];
  1162.   if (yyn == YYFLAG)
  1163.     goto yyerrdefault;
  1164.  
  1165.   yyn += YYTERROR;
  1166.   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
  1167.     goto yyerrdefault;
  1168.  
  1169.   yyn = yytable[yyn];
  1170.   if (yyn < 0)
  1171.     {
  1172.       if (yyn == YYFLAG)
  1173.     goto yyerrpop;
  1174.       yyn = -yyn;
  1175.       goto yyreduce;
  1176.     }
  1177.   else if (yyn == 0)
  1178.     goto yyerrpop;
  1179.  
  1180.   if (yyn == YYFINAL)
  1181.     YYACCEPT;
  1182.  
  1183. #if YYDEBUG != 0
  1184.   if (yydebug)
  1185.     fprintf(stderr, "Shifting error token, ");
  1186. #endif
  1187.  
  1188.   *++yyvsp = yylval;
  1189. #ifdef YYLSP_NEEDED
  1190.   *++yylsp = yylloc;
  1191. #endif
  1192.  
  1193.   yystate = yyn;
  1194.   goto yynewstate;
  1195. }
  1196. #line 343 "cexp.y"
  1197.  
  1198.  
  1199. /* During parsing of a C expression, the pointer to the next character
  1200.    is in this variable.  */
  1201.  
  1202. static char *lexptr;
  1203.  
  1204. /* Take care of parsing a number (anything that starts with a digit).
  1205.    Set yylval and return the token type; update lexptr.
  1206.    LEN is the number of characters in it.  */
  1207.  
  1208. /* maybe needs to actually deal with floating point numbers */
  1209.  
  1210. int
  1211. parse_number (olen)
  1212.      int olen;
  1213. {
  1214.   register char *p = lexptr;
  1215.   register int c;
  1216.   register unsigned long n = 0, nd, ULONG_MAX_over_base;
  1217.   register int base = 10;
  1218.   register int len = olen;
  1219.   register int overflow = 0;
  1220.   register int digit, largest_digit = 0;
  1221.   int spec_long = 0;
  1222.  
  1223.   for (c = 0; c < len; c++)
  1224.     if (p[c] == '.') {
  1225.       /* It's a float since it contains a point.  */
  1226.       yyerror ("floating point numbers not allowed in #if expressions");
  1227.       return ERROR;
  1228.     }
  1229.  
  1230.   yylval.integer.unsignedp = 0;
  1231.  
  1232.   if (len >= 3 && (!strncmp (p, "0x", 2) || !strncmp (p, "0X", 2))) {
  1233.     p += 2;
  1234.     base = 16;
  1235.     len -= 2;
  1236.   }
  1237.   else if (*p == '0')
  1238.     base = 8;
  1239.  
  1240.   ULONG_MAX_over_base = (unsigned long) -1 / base;
  1241.  
  1242.   for (; len > 0; len--) {
  1243.     c = *p++;
  1244.  
  1245.     if (c >= '0' && c <= '9')
  1246.       digit = c - '0';
  1247.     else if (base == 16 && c >= 'a' && c <= 'f')
  1248.       digit = c - 'a' + 10;
  1249.     else if (base == 16 && c >= 'A' && c <= 'F')
  1250.       digit = c - 'A' + 10;
  1251.     else {
  1252.       /* `l' means long, and `u' means unsigned.  */
  1253.       while (1) {
  1254.     if (c == 'l' || c == 'L')
  1255.       {
  1256.         if (spec_long)
  1257.           yyerror ("two `l's in integer constant");
  1258.         spec_long = 1;
  1259.       }
  1260.     else if (c == 'u' || c == 'U')
  1261.       {
  1262.         if (yylval.integer.unsignedp)
  1263.           yyerror ("two `u's in integer constant");
  1264.         yylval.integer.unsignedp = 1;
  1265.       }
  1266.     else
  1267.       break;
  1268.  
  1269.     if (--len == 0)
  1270.       break;
  1271.     c = *p++;
  1272.       }
  1273.       /* Don't look for any more digits after the suffixes.  */
  1274.       break;
  1275.     }
  1276.     if (largest_digit < digit)
  1277.       largest_digit = digit;
  1278.     nd = n * base + digit;
  1279.     overflow |= ULONG_MAX_over_base < n | nd < n;
  1280.     n = nd;
  1281.   }
  1282.  
  1283.   if (len != 0) {
  1284.     yyerror ("Invalid number in #if expression");
  1285.     return ERROR;
  1286.   }
  1287.  
  1288.   if (base <= largest_digit)
  1289.     warning ("integer constant contains digits beyond the radix");
  1290.  
  1291.   if (overflow)
  1292.     warning ("integer constant out of range");
  1293.  
  1294.   /* If too big to be signed, consider it unsigned.  */
  1295.   if ((long) n < 0 && ! yylval.integer.unsignedp)
  1296.     {
  1297.       if (base == 10)
  1298.     warning ("integer constant is so large that it is unsigned");
  1299.       yylval.integer.unsignedp = 1;
  1300.     }
  1301.  
  1302.   lexptr = p;
  1303.   yylval.integer.value = n;
  1304.   return INT;
  1305. }
  1306.  
  1307. struct token {
  1308.   char *operator;
  1309.   int token;
  1310. };
  1311.  
  1312. static struct token tokentab2[] = {
  1313.   {"&&", AND},
  1314.   {"||", OR},
  1315.   {"<<", LSH},
  1316.   {">>", RSH},
  1317.   {"==", EQUAL},
  1318.   {"!=", NOTEQUAL},
  1319.   {"<=", LEQ},
  1320.   {">=", GEQ},
  1321.   {"++", ERROR},
  1322.   {"--", ERROR},
  1323.   {NULL, ERROR}
  1324. };
  1325.  
  1326. /* Read one token, getting characters through lexptr.  */
  1327.  
  1328. int
  1329. yylex ()
  1330. {
  1331.   register int c;
  1332.   register int namelen;
  1333.   register unsigned char *tokstart;
  1334.   register struct token *toktab;
  1335.   int wide_flag;
  1336.  
  1337.  retry:
  1338.  
  1339.   tokstart = (unsigned char *) lexptr;
  1340.   c = *tokstart;
  1341.   /* See if it is a special token of length 2.  */
  1342.   if (! keyword_parsing)
  1343.     for (toktab = tokentab2; toktab->operator != NULL; toktab++)
  1344.       if (c == *toktab->operator && tokstart[1] == toktab->operator[1]) {
  1345.     lexptr += 2;
  1346.     if (toktab->token == ERROR)
  1347.       {
  1348.         char *buf = (char *) alloca (40);
  1349.         sprintf (buf, "`%s' not allowed in operand of `#if'", toktab->operator);
  1350.         yyerror (buf);
  1351.       }
  1352.     return toktab->token;
  1353.       }
  1354.  
  1355.   switch (c) {
  1356.   case 0:
  1357.     return 0;
  1358.     
  1359.   case ' ':
  1360.   case '\t':
  1361.   case '\r':
  1362.   case '\n':
  1363.     lexptr++;
  1364.     goto retry;
  1365.     
  1366.   case 'L':
  1367.     /* Capital L may start a wide-string or wide-character constant.  */
  1368.     if (lexptr[1] == '\'')
  1369.       {
  1370.     lexptr++;
  1371.     wide_flag = 1;
  1372.     goto char_constant;
  1373.       }
  1374.     if (lexptr[1] == '"')
  1375.       {
  1376.     lexptr++;
  1377.     wide_flag = 1;
  1378.     goto string_constant;
  1379.       }
  1380.     break;
  1381.  
  1382.   case '\'':
  1383.     wide_flag = 0;
  1384.   char_constant:
  1385.     lexptr++;
  1386.     if (keyword_parsing) {
  1387.       char *start_ptr = lexptr - 1;
  1388.       while (1) {
  1389.     c = *lexptr++;
  1390.     if (c == '\\')
  1391.       c = parse_escape (&lexptr);
  1392.     else if (c == '\'')
  1393.       break;
  1394.       }
  1395.       yylval.name.address = tokstart;
  1396.       yylval.name.length = lexptr - start_ptr;
  1397.       return NAME;
  1398.     }
  1399.  
  1400.     /* This code for reading a character constant
  1401.        handles multicharacter constants and wide characters.
  1402.        It is mostly copied from c-lex.c.  */
  1403.     {
  1404.       register int result = 0;
  1405.       register num_chars = 0;
  1406.       unsigned width = MAX_CHAR_TYPE_SIZE;
  1407.       int max_chars;
  1408.       char *token_buffer;
  1409.  
  1410.       if (wide_flag)
  1411.     {
  1412.       width = MAX_WCHAR_TYPE_SIZE;
  1413. #ifdef MULTIBYTE_CHARS
  1414.       max_chars = MB_CUR_MAX;
  1415. #else
  1416.       max_chars = 1;
  1417. #endif
  1418.     }
  1419.       else
  1420.     max_chars = MAX_LONG_TYPE_SIZE / width;
  1421.  
  1422.       token_buffer = (char *) alloca (max_chars + 1);
  1423.  
  1424.       while (1)
  1425.     {
  1426.       c = *lexptr++;
  1427.  
  1428.       if (c == '\'' || c == EOF)
  1429.         break;
  1430.  
  1431.       if (c == '\\')
  1432.         {
  1433.           c = parse_escape (&lexptr);
  1434.           if (width < HOST_BITS_PER_INT
  1435.           && (unsigned) c >= (1 << width))
  1436.         pedwarn ("escape sequence out of range for character");
  1437.         }
  1438.  
  1439.       num_chars++;
  1440.  
  1441.       /* Merge character into result; ignore excess chars.  */
  1442.       if (num_chars < max_chars + 1)
  1443.         {
  1444.           if (width < HOST_BITS_PER_INT)
  1445.         result = (result << width) | (c & ((1 << width) - 1));
  1446.           else
  1447.         result = c;
  1448.           token_buffer[num_chars - 1] = c;
  1449.         }
  1450.     }
  1451.  
  1452.       token_buffer[num_chars] = 0;
  1453.  
  1454.       if (c != '\'')
  1455.     error ("malformatted character constant");
  1456.       else if (num_chars == 0)
  1457.     error ("empty character constant");
  1458.       else if (num_chars > max_chars)
  1459.     {
  1460.       num_chars = max_chars;
  1461.       error ("character constant too long");
  1462.     }
  1463.       else if (num_chars != 1 && ! traditional)
  1464.     warning ("multi-character character constant");
  1465.  
  1466.       /* If char type is signed, sign-extend the constant.  */
  1467.       if (! wide_flag)
  1468.     {
  1469.       int num_bits = num_chars * width;
  1470.  
  1471.       if (lookup ("__CHAR_UNSIGNED__", sizeof ("__CHAR_UNSIGNED__")-1, -1)
  1472.           || ((result >> (num_bits - 1)) & 1) == 0)
  1473.         yylval.integer.value
  1474.           = result & ((unsigned long) ~0 >> (HOST_BITS_PER_LONG - num_bits));
  1475.       else
  1476.         yylval.integer.value
  1477.           = result | ~((unsigned long) ~0 >> (HOST_BITS_PER_LONG - num_bits));
  1478.     }
  1479.       else
  1480.     {
  1481. #ifdef MULTIBYTE_CHARS
  1482.       /* Set the initial shift state and convert the next sequence.  */
  1483.       result = 0;
  1484.       /* In all locales L'\0' is zero and mbtowc will return zero,
  1485.          so don't use it.  */
  1486.       if (num_chars > 1
  1487.           || (num_chars == 1 && token_buffer[0] != '\0'))
  1488.         {
  1489.           wchar_t wc;
  1490.           (void) mbtowc (NULL_PTR, NULL_PTR, 0);
  1491.           if (mbtowc (& wc, token_buffer, num_chars) == num_chars)
  1492.         result = wc;
  1493.           else
  1494.         warning ("Ignoring invalid multibyte character");
  1495.         }
  1496. #endif
  1497.       yylval.integer.value = result;
  1498.     }
  1499.     }
  1500.  
  1501.     /* This is always a signed type.  */
  1502.     yylval.integer.unsignedp = 0;
  1503.     
  1504.     return CHAR;
  1505.  
  1506.     /* some of these chars are invalid in constant expressions;
  1507.        maybe do something about them later */
  1508.   case '/':
  1509.   case '+':
  1510.   case '-':
  1511.   case '*':
  1512.   case '%':
  1513.   case '|':
  1514.   case '&':
  1515.   case '^':
  1516.   case '~':
  1517.   case '!':
  1518.   case '@':
  1519.   case '<':
  1520.   case '>':
  1521.   case '[':
  1522.   case ']':
  1523.   case '.':
  1524.   case '?':
  1525.   case ':':
  1526.   case '=':
  1527.   case '{':
  1528.   case '}':
  1529.   case ',':
  1530.   case '#':
  1531.     if (keyword_parsing)
  1532.       break;
  1533.   case '(':
  1534.   case ')':
  1535.     lexptr++;
  1536.     return c;
  1537.  
  1538.   case '"':
  1539.   string_constant:
  1540.     if (keyword_parsing) {
  1541.       char *start_ptr = lexptr;
  1542.       lexptr++;
  1543.       while (1) {
  1544.     c = *lexptr++;
  1545.     if (c == '\\')
  1546.       c = parse_escape (&lexptr);
  1547.     else if (c == '"')
  1548.       break;
  1549.       }
  1550.       yylval.name.address = tokstart;
  1551.       yylval.name.length = lexptr - start_ptr;
  1552.       return NAME;
  1553.     }
  1554.     yyerror ("string constants not allowed in #if expressions");
  1555.     return ERROR;
  1556.   }
  1557.  
  1558.   if (c >= '0' && c <= '9' && !keyword_parsing) {
  1559.     /* It's a number */
  1560.     for (namelen = 0;
  1561.      c = tokstart[namelen], is_idchar[c] || c == '.'; 
  1562.      namelen++)
  1563.       ;
  1564.     return parse_number (namelen);
  1565.   }
  1566.  
  1567.   /* It is a name.  See how long it is.  */
  1568.  
  1569.   if (keyword_parsing) {
  1570.     for (namelen = 0;; namelen++) {
  1571.       if (is_hor_space[tokstart[namelen]])
  1572.     break;
  1573.       if (tokstart[namelen] == '(' || tokstart[namelen] == ')')
  1574.     break;
  1575.       if (tokstart[namelen] == '"' || tokstart[namelen] == '\'')
  1576.     break;
  1577.     }
  1578.   } else {
  1579.     if (!is_idstart[c]) {
  1580.       yyerror ("Invalid token in expression");
  1581.       return ERROR;
  1582.     }
  1583.  
  1584.     for (namelen = 0; is_idchar[tokstart[namelen]]; namelen++)
  1585.       ;
  1586.   }
  1587.   
  1588.   lexptr += namelen;
  1589.   yylval.name.address = tokstart;
  1590.   yylval.name.length = namelen;
  1591.   return NAME;
  1592. }
  1593.  
  1594.  
  1595. /* Parse a C escape sequence.  STRING_PTR points to a variable
  1596.    containing a pointer to the string to parse.  That pointer
  1597.    is updated past the characters we use.  The value of the
  1598.    escape sequence is returned.
  1599.  
  1600.    A negative value means the sequence \ newline was seen,
  1601.    which is supposed to be equivalent to nothing at all.
  1602.  
  1603.    If \ is followed by a null character, we return a negative
  1604.    value and leave the string pointer pointing at the null character.
  1605.  
  1606.    If \ is followed by 000, we return 0 and leave the string pointer
  1607.    after the zeros.  A value of 0 does not mean end of string.  */
  1608.  
  1609. int
  1610. parse_escape (string_ptr)
  1611.      char **string_ptr;
  1612. {
  1613.   register int c = *(*string_ptr)++;
  1614.   switch (c)
  1615.     {
  1616.     case 'a':
  1617.       return TARGET_BELL;
  1618.     case 'b':
  1619.       return TARGET_BS;
  1620.     case 'e':
  1621.     case 'E':
  1622.       if (pedantic)
  1623.     pedwarn ("non-ANSI-standard escape sequence, `\\%c'", c);
  1624.       return 033;
  1625.     case 'f':
  1626.       return TARGET_FF;
  1627.     case 'n':
  1628.       return TARGET_NEWLINE;
  1629.     case 'r':
  1630.       return TARGET_CR;
  1631.     case 't':
  1632.       return TARGET_TAB;
  1633.     case 'v':
  1634.       return TARGET_VT;
  1635.     case '\n':
  1636.       return -2;
  1637.     case 0:
  1638.       (*string_ptr)--;
  1639.       return 0;
  1640.       
  1641.     case '0':
  1642.     case '1':
  1643.     case '2':
  1644.     case '3':
  1645.     case '4':
  1646.     case '5':
  1647.     case '6':
  1648.     case '7':
  1649.       {
  1650.     register int i = c - '0';
  1651.     register int count = 0;
  1652.     while (++count < 3)
  1653.       {
  1654.         c = *(*string_ptr)++;
  1655.         if (c >= '0' && c <= '7')
  1656.           i = (i << 3) + c - '0';
  1657.         else
  1658.           {
  1659.         (*string_ptr)--;
  1660.         break;
  1661.           }
  1662.       }
  1663.     if ((i & ~((1 << MAX_CHAR_TYPE_SIZE) - 1)) != 0)
  1664.       {
  1665.         i &= (1 << MAX_CHAR_TYPE_SIZE) - 1;
  1666.         warning ("octal character constant does not fit in a byte");
  1667.       }
  1668.     return i;
  1669.       }
  1670.     case 'x':
  1671.       {
  1672.     register unsigned i = 0, overflow = 0, digits_found = 0, digit;
  1673.     for (;;)
  1674.       {
  1675.         c = *(*string_ptr)++;
  1676.         if (c >= '0' && c <= '9')
  1677.           digit = c - '0';
  1678.         else if (c >= 'a' && c <= 'f')
  1679.           digit = c - 'a' + 10;
  1680.         else if (c >= 'A' && c <= 'F')
  1681.           digit = c - 'A' + 10;
  1682.         else
  1683.           {
  1684.         (*string_ptr)--;
  1685.         break;
  1686.           }
  1687.         overflow |= i ^ (i << 4 >> 4);
  1688.         i = (i << 4) + digit;
  1689.         digits_found = 1;
  1690.       }
  1691.     if (!digits_found)
  1692.       yyerror ("\\x used with no following hex digits");
  1693.     if (overflow | (i & ~((1 << BITS_PER_UNIT) - 1)))
  1694.       {
  1695.         i &= (1 << BITS_PER_UNIT) - 1;
  1696.         warning ("hex character constant does not fit in a byte");
  1697.       }
  1698.     return i;
  1699.       }
  1700.     default:
  1701.       return c;
  1702.     }
  1703. }
  1704.  
  1705. void
  1706. yyerror (s)
  1707.      char *s;
  1708. {
  1709.   error (s);
  1710.   longjmp (parse_return_error, 1);
  1711. }
  1712.  
  1713. static void
  1714. integer_overflow ()
  1715. {
  1716.   if (pedantic)
  1717.     pedwarn ("integer overflow in preprocessor expression");
  1718. }
  1719.  
  1720. static long
  1721. left_shift (a, b)
  1722.      struct constant *a;
  1723.      unsigned long b;
  1724. {
  1725.   if (b >= HOST_BITS_PER_LONG)
  1726.     {
  1727.       if (! a->unsignedp && a->value != 0)
  1728.     integer_overflow ();
  1729.       return 0;
  1730.     }
  1731.   else if (a->unsignedp)
  1732.     return (unsigned long) a->value << b;
  1733.   else
  1734.     {
  1735.       long l = a->value << b;
  1736.       if (l >> b != a->value)
  1737.     integer_overflow ();
  1738.       return l;
  1739.     }
  1740. }
  1741.  
  1742. static long
  1743. right_shift (a, b)
  1744.      struct constant *a;
  1745.      unsigned long b;
  1746. {
  1747.   if (b >= HOST_BITS_PER_LONG)
  1748.     return a->unsignedp ? 0 : a->value >> (HOST_BITS_PER_LONG - 1);
  1749.   else if (a->unsignedp)
  1750.     return (unsigned long) a->value >> b;
  1751.   else
  1752.     return a->value >> b;
  1753. }
  1754.  
  1755. /* This page contains the entry point to this file.  */
  1756.  
  1757. /* Parse STRING as an expression, and complain if this fails
  1758.    to use up all of the contents of STRING.  */
  1759. /* We do not support C comments.  They should be removed before
  1760.    this function is called.  */
  1761.  
  1762. int
  1763. parse_c_expression (string)
  1764.      char *string;
  1765. {
  1766.   lexptr = string;
  1767.   
  1768.   if (lexptr == 0 || *lexptr == 0) {
  1769.     error ("empty #if expression");
  1770.     return 0;            /* don't include the #if group */
  1771.   }
  1772.  
  1773.   /* if there is some sort of scanning error, just return 0 and assume
  1774.      the parsing routine has printed an error message somewhere.
  1775.      there is surely a better thing to do than this.     */
  1776.   if (setjmp (parse_return_error))
  1777.     return 0;
  1778.  
  1779.   if (yyparse ())
  1780.     return 0;            /* actually this is never reached
  1781.                    the way things stand. */
  1782.   if (*lexptr)
  1783.     error ("Junk after end of expression.");
  1784.  
  1785.   return expression_value;    /* set by yyparse () */
  1786. }
  1787.  
  1788. #ifdef TEST_EXP_READER
  1789. extern int yydebug;
  1790.  
  1791. /* Main program for testing purposes.  */
  1792. int
  1793. main ()
  1794. {
  1795.   int n, c;
  1796.   char buf[1024];
  1797.  
  1798. /*
  1799.   yydebug = 1;
  1800. */
  1801.   initialize_random_junk ();
  1802.  
  1803.   for (;;) {
  1804.     printf ("enter expression: ");
  1805.     n = 0;
  1806.     while ((buf[n] = getchar ()) != '\n' && buf[n] != EOF)
  1807.       n++;
  1808.     if (buf[n] == EOF)
  1809.       break;
  1810.     buf[n] = '\0';
  1811.     printf ("parser returned %d\n", parse_c_expression (buf));
  1812.   }
  1813.  
  1814.   return 0;
  1815. }
  1816.  
  1817. /* table to tell if char can be part of a C identifier. */
  1818. unsigned char is_idchar[256];
  1819. /* table to tell if char can be first char of a c identifier. */
  1820. unsigned char is_idstart[256];
  1821. /* table to tell if c is horizontal space.  isspace () thinks that
  1822.    newline is space; this is not a good idea for this program. */
  1823. char is_hor_space[256];
  1824.  
  1825. /*
  1826.  * initialize random junk in the hash table and maybe other places
  1827.  */
  1828. initialize_random_junk ()
  1829. {
  1830.   register int i;
  1831.  
  1832.   /*
  1833.    * Set up is_idchar and is_idstart tables.  These should be
  1834.    * faster than saying (is_alpha (c) || c == '_'), etc.
  1835.    * Must do set up these things before calling any routines tthat
  1836.    * refer to them.
  1837.    */
  1838.   for (i = 'a'; i <= 'z'; i++) {
  1839.     ++is_idchar[i - 'a' + 'A'];
  1840.     ++is_idchar[i];
  1841.     ++is_idstart[i - 'a' + 'A'];
  1842.     ++is_idstart[i];
  1843.   }
  1844.   for (i = '0'; i <= '9'; i++)
  1845.     ++is_idchar[i];
  1846.   ++is_idchar['_'];
  1847.   ++is_idstart['_'];
  1848. #if DOLLARS_IN_IDENTIFIERS
  1849.   ++is_idchar['$'];
  1850.   ++is_idstart['$'];
  1851. #endif
  1852.  
  1853.   /* horizontal space table */
  1854.   ++is_hor_space[' '];
  1855.   ++is_hor_space['\t'];
  1856. }
  1857.  
  1858. error (msg)
  1859. {
  1860.   printf ("error: %s\n", msg);
  1861. }
  1862.  
  1863. warning (msg)
  1864. {
  1865.   printf ("warning: %s\n", msg);
  1866. }
  1867.  
  1868. struct hashnode *
  1869. lookup (name, len, hash)
  1870.      char *name;
  1871.      int len;
  1872.      int hash;
  1873. {
  1874.   return (DEFAULT_SIGNED_CHAR) ? 0 : ((struct hashnode *) -1);
  1875. }
  1876. #endif
  1877.